Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume10/ifp/part01

Internet Message Format | 1987-07-05 | 25.8 KB

Path: uunet!rs
From: [e-mail] (Rich Salz)
Newsgroups: comp.sources.unix
Subject: v10i034: Interpreted Functional Programming lanuage, Part 01/07
Message-ID: <[e-mail]>
Date: 7 Jul 87 04:32:07 GMT
Organization: UUNET Communications Services, Arlington, VA
Lines: 1224
Approved: [e-mail]

Mod.sources: Volume 10, Number 34
Submitted by: [e-mail] (Arch Robison)
Archive-name: ifp/Part01

IFP[1] is a variant of Backus' FP [2].  The IFP interpreter is written
in C and is an order of magnitude faster than the BSD 4.2 FP [3].
The interpreter should run on any UNIX box.

Arch D. Robison
University of Illinois at Urbana-Champaign

CSNET: [e-mail]
UUCP: {ihnp4,pur-ee,convex}!uiucdcs!robison
ARPA: [e-mail] ([e-mail])

General References
------------------

[1]  Arch D. Robison, "Illinois  Functional  Programming:  A
     Tutorial," BYTE Vol. 12,2 pp. 115-125 McGraw-Hill Inc.,
     (February 1987).

[2]  John Backus, "Can Programming Be Liberated from the von
     Neumann  Style?   A Functional Style and Its Algebra of
     Programs," CACM  Vol.  21,8 pp.  613-641  ACM,  (August
     1978).

[3]  Scott Baden, "Berkeley FP  User's  Manual,  Rev.  4.1,"
     UNIX Programmers Manual, (July 27,1983).


#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh.
# The following files will be created:
#    README
#    ifp.1
#    RunIFP
#    fproot
export PATH; PATH=/bin:$PATH
if test -f 'README'
then
    echo shar: over-writing existing file "'README'"
fi
cat << \SHAR_EOF > 'README'
This directory contains the following subdirectories and files:

    README - this file

    RunIFP - shell script which runs IFP interpreter

    fproot - IFP demonstration root directory
    fproot/demo - demonstration functions

    interp - source code and Makefile for IFP interpreter

    manual - troff files and Makefile for IFP manual
SHAR_EOF
chmod +x 'README'
if test -f 'ifp.1'
then
    echo shar: over-writing existing file "'ifp.1'"
fi
cat << \SHAR_EOF > 'ifp.1'
.TH IFP 1 "Jan 28, 1987"
.UC 4
.SH NAME
ifp \- Illinois FP interpreter
.SH SYNOPSIS
.B ifp
[ option ]
.SH DESCRIPTION
.I Ifp
starts the Illinois FP interpreter.
.PP
.I Ifp
understands several options.  Normally, no options are required.
Most of the options are for experimental work.
Not all (or even any) of the options may
exist for a particular version of the interpreter.
.TP
.B \-l
Print all functions with full pathname.
Useful for debugging scope problems.
.TP
.B \-e[012]
Turn on expression cache.  The cache may be turned on for any subset of:
.nf
    0    Primitive functions
    1    User-defined functions
    2    PFOs
.fi
To see the cache statistics, give the command "cache" to the interpreter.
.TP
.B \-pn
(Multimax only) This option specifies that the interpreter should be run
as n parallel processes.
.TP
.B \-f
(Multimax only) Print expression queue statistics.
.TP
.B  \-sn
(Multimax only) Use stack of max. depth n for expression scheduling.
.TP
.B \-qn
(Multimax only) Use queue of max. length n for expression scheduling.
.TP
.B \-d[pafricxhusle]
Turn on spy points corresponding to selected letters.
.nf
    p    parser
    a    memory allocation
    f    file io
    r    reference counts
    i    initialization
    c    expression cache
    x    extended definitions
    h    hypercube
    u    Multimax
    s    Semaphores
    l    Free list
    e    Expression sckeduling
.fi
For example, -dar turns on spy points for memory allocation and
reference counts.
.SH FILES
.ta \w'/usr/local/lib/lib*.a\ \ 'u
ifp    interpreter
.br
.SH "SEE ALSO"
Illinois FP User's Manual
.sp 2
A Functional Programming Interpreter (THESIS, Univerisity of Illinois)
.sp 2
.ul
Illinois Functional Programming: A Tutorial
(BYTE, Feb. 1987)
.br
fp(1)
.SH BUGS
Programming in IFP still requires thinking.  Some the options are incompatible.
.SH AUTHOR
Arch D. Robison
SHAR_EOF
if test -f 'RunIFP'
then
    echo shar: over-writing existing file "'RunIFP'"
fi
cat << \SHAR_EOF > 'RunIFP'
# Shell script for invoking IFP interpreter.

# This script is for demonstration and documentation purposes only.
# Running the script will set the appropriate environment variables
# and start up the IFP interpreter in the demonstration directory.

# All its actions should be put in the user's .login, and .cshrc files.
# The IFP interpreter must be compiled before running this script.
# See the Makefile in subdirectory "interp" for instructions on how
# to compile the interpreter.

#-----------------------------------------------------------------------

# These two lines should go in each user's .login file and be customized
# for the user's particular IFP root directory and editor.

    setenv IFProot $cwd/fproot
    setenv EDITOR "/usr/ucb/vi"

# This alias is for convenience.  Presumably the interpreter will normally
# reside on the user's search path.

    alias ifp $cwd/interp/ifp

# Normally the user would type in the following two lines:

    cd fproot/demo
    ifp

# The interpreter will respond with the prompt "ifp>" when ready for
# user input.

SHAR_EOF
chmod +x 'RunIFP'
if test ! -d 'fproot'
then
    mkdir 'fproot'
fi
cd 'fproot'
if test ! -d 'demo'
then
    mkdir 'demo'
fi
cd 'demo'
if test -f '%IMPORT'
then
    echo shar: over-writing existing file "'%IMPORT'"
fi
cat << \SHAR_EOF > '%IMPORT'
FROM /sys IMPORT
   apndl,apndr,apply,assoc,cat,distl,distr,dropl,dropr,explode,id,implode,
   iota,length,patom,pick,repeat,reverse,takel,taker,tl,tlr,trans;

FROM /math/arith IMPORT
   +,-,*,%,add1,arccos,arcsin,arctan,cos,div,exp,ln,
   max,min,mod,minus,power,prod,sin,sqrt,sub1,sum,tan;

FROM /math/logic IMPORT
   <,<=,=,~=,>=,>,~,and,all,any,atom,boolean,false,longer,member,null,
   numeric,odd,or,pair,shorter,xor;

SHAR_EOF
if test -f 'A'
then
    echo shar: over-writing existing file "'A'"
fi
cat << \SHAR_EOF > 'A'
DEF A AS
  #<<1 2 3>
    <4 5 6>
    <7 8 9>>;
SHAR_EOF
if test -f 'Abs'
then
    echo shar: over-writing existing file "'Abs'"
fi
cat << \SHAR_EOF > 'Abs'
(* Absolute value function *)

DEF Abs AS
   IF [id,#0] | < THEN minus
   ELSE id
   END;
SHAR_EOF
if test -f 'B'
then
    echo shar: over-writing existing file "'B'"
fi
cat << \SHAR_EOF > 'B'
(*
 * A data matrix.
 *)
DEF B AS
   #<5 3 88  6 21  0  0 -7
     5 2  1  4  8 10  1  4
     2 4  3  7  9  5  2  5
     1 3  3  5  7  2  3  6
     4 7  5  3  1  8  4  7
     8 9  7  1  6 12  5  8
    10 5  2  8 12  1  6  9
     1 2  3  4  5  6  1  2
     4 5  6  7  8  9  2  1>;

SHAR_EOF
if test -f 'Cart'
then
    echo shar: over-writing existing file "'Cart'"
fi
cat << \SHAR_EOF > 'Cart'
(*
 * Cartesian product of two sequences
 *)
DEF Cart AS
   distr | EACH distl END;

SHAR_EOF
if test -f 'CosSin'
then
    echo shar: over-writing existing file "'CosSin'"
fi
cat << \SHAR_EOF > 'CosSin'
(*
 * CosSin
 *
 * Compute the sine and cosine of an angle via half-angle formulae.
 * The function is accurate to 12 decimals.
 *)
DEF CosSin AS
   IF [id|Abs,#1e-6]|< THEN [[#1,[Square,#2]|%]|-,id]
   ELSE
      [id,#2]|% | CosSin |
      [[+,-]|*, [*,*]|+]
   END;

SHAR_EOF
if test -f 'Data'
then
    echo shar: over-writing existing file "'Data'"
fi
cat << \SHAR_EOF > 'Data'
(*
 * Currently I/O is almost non-existent in IFP.  One way to skirt this problem
 * when you have a large amount of data to input is to define a constant
 * function with the appropriate values.
 *
 * The function Data returns a sequence of data values.  We could, for
 * instance, sort them by composing Data with QuickSort
 *
 * Examples:
 *      0 : Data -> <5 3 88 6 21 0 -7>
 *      0 : Data | QuickSort -> <-7 0 3 5 6 21 88>
 *)

DEF Data AS
   #<5 3 88 6 21 0 -7>;

SHAR_EOF
if test -f 'Debug'
then
    echo shar: over-writing existing file "'Debug'"
fi
cat << \SHAR_EOF > 'Debug'
(*
 * Version of Fib with debugging output
 *
 * n : Debug -> sequence of first n Fibonacci numbers
 *
 * The two functions created with the "@" form print their inputs
 * so we can see what is going on inside the Debug function.
 *)

DEF Debug AS

   IF [id,#2] | <= THEN

      @"trivial case" | [#<1 1>,id] | takel

   ELSE

      @"recurse" | sub1 | Debug | [id, [1r,2r]|+] | apndr

   END;

SHAR_EOF
if test -f 'Double'
then
    echo shar: over-writing existing file "'Double'"
fi
cat << \SHAR_EOF > 'Double'
(* Double a number - e.g. 3:Double -> 6 *)

DEF Double AS [id,id]|+;

SHAR_EOF
if test -f 'Fib'
then
    echo shar: over-writing existing file "'Fib'"
fi
cat << \SHAR_EOF > 'Fib'
(*
 * Compute nth fibonacci number
 *
 * Examples:
 *
 *    6 : Fib -> 8
 *    7 : Fib -> 13
 *    8 : Fib -> 21
 *)

DEF Fib AS
   IF [id,#2] | < THEN id
   ELSE
      sub1 | [Fib,sub1|Fib] | +
   END;
SHAR_EOF
if test -f 'FibSeq'
then
    echo shar: over-writing existing file "'FibSeq'"
fi
cat << \SHAR_EOF > 'FibSeq'
(*
 * Fibonacci numbers
 *
 * n : FibSeq -> sequence of first n Fibonacci numbers
 *
 * Example
 *      6 : FibSeq -> <1 1 2 3 5 8>
 *)

DEF FibSeq AS
   IF [id,#2] | <= THEN
      [#<1 1>,id] | takel       (* trivial case *)
   ELSE
      sub1 | FibSeq |           (* generate n-1 Fibonacci numbers        *)
      [id, [1r,2r]|+] | apndr   (* append sum of last two to end of list *)
   END;

SHAR_EOF
if test -f 'Format'
then
    echo shar: over-writing existing file "'Format'"
fi
cat << \SHAR_EOF > 'Format'
DEF Format AS
   [id,#" "] | distr | cat | implode;

SHAR_EOF
if test -f 'Hanoi'
then
    echo shar: over-writing existing file "'Hanoi'"
fi
cat << \SHAR_EOF > 'Hanoi'
(*
 * Hanio - towers of Hanoi solver
 *
 * <N Names> : Hanoi -> <<src dst> ...<src dst>>
 *
 * where N is number of rings and names is a triple of post names
 * <source temporary dest>.
 *
 * Example:
 *    <2 <a b c>> : Hanoi -> <<a,b>,<a,c>,<b,c>>
 *)

DEF Hanoi AS
   {[n,[a,b,c]] := id}
   IF [n,#0]|= THEN []
   ELSE [
      [n|sub1, [a,c,b]] | Hanoi,
      [[a,c]],
      [n|sub1, [b,a,c]] | Hanoi
   ] | cat
   END;

SHAR_EOF
if test -f 'Inner'
then
    echo shar: over-writing existing file "'Inner'"
fi
cat << \SHAR_EOF > 'Inner'
(*
 * Compute the inner product of two vectors.
 *)
DEF Inner AS
   trans | EACH * END | INSERT + END;
SHAR_EOF
if test -f 'InsertSort'
then
    echo shar: over-writing existing file "'InsertSort'"
fi
cat << \SHAR_EOF > 'InsertSort'
(*
 * InsertSort
 *
 * This function sorts a sequence of numbers or strings into ascending order
 * using insertion sort.
 *
 * Examples:
 *
 *      <3 1 4 1 5 9 2> : InsertSort == <1 1 2 3 4 5 9>
 *
 *      <all work and no play> : InsertSort == <all and no play work>
 *
 * The sequence may not mix strings and numbers.
 *)
DEF InsertSort AS
   IF null THEN id            (* Check for trivial case *)
   ELSE
      [tl,[1]] | apndr |
      INSERT
     {[Element,Seq] := id}
         {[Left,Right] := [Seq, distl | FILTER > END | length] | [takel,dropl]}
     [Left,[Element],Right] | cat
      END
   END;

SHAR_EOF
if test -f 'Inter'
then
    echo shar: over-writing existing file "'Inter'"
fi
cat << \SHAR_EOF > 'Inter'
(*
 * Set intersection: [A,B] : Inter -> elements of B which are in A
 *
 * Example:
 *      <<2 3 4> <5 3 2 1>> : Inter -> <3 2>
 *)

DEF Inter AS
   distl | FILTER member END | EACH 2 END;
SHAR_EOF
if test -f 'MatMul'
then
    echo shar: over-writing existing file "'MatMul'"
fi
cat << \SHAR_EOF > 'MatMul'
(*
 * MatMul
 *
 * [matrixA,matrixB] -> matrixAB
 *)
DEF MatMul AS
   {[A,B] := id}
   [A,B|trans] | distr |
   EACH distl |
      EACH Inner END
   END;
SHAR_EOF
if test -f 'Member'
then
    echo shar: over-writing existing file "'Member'"
fi
cat << \SHAR_EOF > 'Member'
(*
 * <S e> : Member -> #t if e is in sequence S, #f otherwise
 *
 * Examples:
 *      <<a b c d> c> -> t
 *      <<2 4 6 8> 3> -> f
 *)
DEF Member AS
   distr | EACH = END | any;

SHAR_EOF
if test -f 'Merge'
then
    echo shar: over-writing existing file "'Merge'"
fi
cat << \SHAR_EOF > 'Merge'
(*
 * Merge
 *
 * Merge two ascending sequences.
 *
 * The sequences should not mix strings and numbers.
 *
 * Example:
 *
 *    <<a b x z> <c d z>> : Merge -> <a b c d x y z>
 *)
DEF Merge AS
   IF EACH null END | or THEN cat
   ELSE
      IF EACH 1 END | > THEN reverse ELSE id END |
      [1|1,[1|tl,2]|Merge] | apndl
   END;

SHAR_EOF
if test -f 'MergeSort'
then
    echo shar: over-writing existing file "'MergeSort'"
fi
cat << \SHAR_EOF > 'MergeSort'
(*
 * MergeSort
 *
 * This function sorts a sequence of numbers or strings into ascending order
 * using merge sort.
 *
 * Examples:
 *
 *      <3 1 4 1 5 9 2> : MergeSort == <1 1 2 3 4 5 9>
 *
 *      <all work and no play> : MergeSort == <all and no play work>
 *
 * The sequence may not mix strings and numbers.
 *)
DEF MergeSort AS
   IF [length,#2] | < THEN id
   ELSE
       [id, [length,#2] | div] |
       [takel,dropl] | EACH MergeSort END | Merge
   END;

SHAR_EOF
if test -f 'Outer'
then
    echo shar: over-writing existing file "'Outer'"
fi
cat << \SHAR_EOF > 'Outer'
(*
 * Outer product of two vectors
 *)
DEF Outer AS
   Cart | EACH EACH * END END;

SHAR_EOF
if test -f 'PasTri'
then
    echo shar: over-writing existing file "'PasTri'"
fi
cat << \SHAR_EOF > 'PasTri'
(*
 * Pascal's triangle generator
 *
 * n : PasTri -> first n rows of Pascal's triangle
 *
 * Example
 *              5 : PasTri -> <
 *                               <1>
 *                               <1 1>
 *                               <1 2 1>
 *                               <1 3 3 1>
 *                               <1 4 6 4 1>
 *                            >
 *)

DEF PasTri AS
   IF [id,#0] | <= THEN #<<1>>
   ELSE
      sub1 | PasTri |                (* Create triangle with n-1 rows *)
      [
         id,

         1r |                        (* Take last row of smaller triangle *)
         [
            [#0,id] | apndl,         (* Append 0 to left edge of row  *)
            [id,#0] | apndr          (* Append 0 to right edge of row *)
         ] | trans | EACH + END      (* Add corresponding elements *)

      ] | apndr                      (* Append new row to smaller triangle *)
   END;




SHAR_EOF
if test -f 'Permute'
then
    echo shar: over-writing existing file "'Permute'"
fi
cat << \SHAR_EOF > 'Permute'
DEF Permute AS
   IF null THEN #<<>>
   ELSE
      [id,length|iota] | distl |
      EACH
     [pick,[takel|tlr,dropl]|cat|Permute] | distl | EACH apndl END
      END | cat
   END;
SHAR_EOF
if test -f 'PigLatin'
then
    echo shar: over-writing existing file "'PigLatin'"
fi
cat << \SHAR_EOF > 'PigLatin'
(*
 * Convert sequence of words to pig-latin
 *
 * E.g.
 *      <Have a nice day> : PigLatin -> <aveHay a icenay ayday>
 *
 * The text processing is done via explode and implode.
 * `explode' converts a string into a sequence of characters (1 letter strings),
 * `implode' catenates a sequence of strings into a single string.
 *
 * Coded by Kevin Kenny and Arch Robison
 *)

DEF PigLatin AS

   EACH
      explode |

      IF EACH Vowel END | any | ~ THEN id    (* Not a word, don't mangle it *)
      ELSE

         IF 1|Vowel|~ THEN

            (* Word begins with a consonant - rotate first vowel to front. *)

            WHILE 1|Vowel|~ DO
               [tl,1]|apndr
            END

         ELSIF [1r|Vowel, [#<y Y>,1r]|member] | or THEN

            (* Word ends in vowel or 'y' - append a 'w' *)

            [id,#w] | apndr

         ELSE id
         END |

         [id,#<a y>] | cat

      END |

      implode
   END;

SHAR_EOF
if test -f 'PowerSet'
then
    echo shar: over-writing existing file "'PowerSet'"
fi
cat << \SHAR_EOF > 'PowerSet'
(*
 * PowerSet
 *
 * This function generates all subsets of a given set.  Sets are
 * represented as sequences of distinct elements.
 *
 * Examples:
 *
 *      <> : PowerSet -> <<>>
 *
 *      <a b c> : PowerSet -> <<a,b,c>,<a,b>,<a,c>,<a>,<b,c>,<b>,<c>,<>>
 *)

DEF PowerSet AS
   IF null THEN [id]
   ELSE
      [1, tl | PowerSet] |
      [
         distl | EACH apndl END,
     2
      ]
      | cat
   END;

SHAR_EOF
if test -f 'QuickSort'
then
    echo shar: over-writing existing file "'QuickSort'"
fi
cat << \SHAR_EOF > 'QuickSort'
(*
 * QuickSort
 *
 * This function sorts a sequence of numbers or strings into ascending order
 * using the Quicksort algorithm.
 *
 * Examples:
 *
 *      <3 1 4 1 5 9 2> : QuickSort == <1 1 2 3 4 5 9>
 *
 *      <all work and no play> : QuickSort == <all and no play work>
 *
 * The sequence may not mix strings and numbers.
 *)

DEF QuickSort AS
   IF [length,#2] | < THEN id
   ELSE
      [id,1] | distr |
      [
         FILTER < END | EACH 1 END | QuickSort,
         FILTER = END | EACH 1 END,
         FILTER > END | EACH 1 END | QuickSort
      ] | cat
   END;

SHAR_EOF
if test -f 'SelSort'
then
    echo shar: over-writing existing file "'SelSort'"
fi
cat << \SHAR_EOF > 'SelSort'
(*
 * Selection sort
 *
 * Example:
 *
 *      <3 1 4 1 5 9 2> : SelSort == <1 1 2 3 4 5 9>
 *
 * The sequence must be numeric.
 *)
DEF SelSort AS
   IF [length,#2] | < THEN id
   ELSE
      [INSERT min END,id] | distl |
      [
         FILTER  = END | EACH 2 END,
         FILTER ~= END | EACH 2 END | SelSort
      ] | cat
   END;

SHAR_EOF
if test -f 'SlowSort'
then
    echo shar: over-writing existing file "'SlowSort'"
fi
cat << \SHAR_EOF > 'SlowSort'
(*
 * SlowSort
 *
 * Sort a sequence the hard way, i.e. take all permutations
 * and pick one for which all elements are in order.
 *)
DEF SlowSort AS
   Permute |
   FILTER
      [tl,tlr]|trans | EACH >= END | all
   END | 1;

SHAR_EOF
if test -f 'Square'
then
    echo shar: over-writing existing file "'Square'"
fi
cat << \SHAR_EOF > 'Square'
(* Square a number - e.g. 3:Square -> 9 *)

DEF Square AS [id,id]|*;

SHAR_EOF
if test -f 'Tangent'
then
    echo shar: over-writing existing file "'Tangent'"
fi
cat << \SHAR_EOF > 'Tangent'
(* Trigonometric tangent function *)

DEF Tangent AS [sin,cos]|%;
SHAR_EOF
if test -f 'Text'
then
    echo shar: over-writing existing file "'Text'"
fi
cat << \SHAR_EOF > 'Text'
(*
 * Text
 *
 * Example piece of text for use with PigLatin function.
 *
 * Example:
 *
 *    0 : Text | PigLatin -> ...
 *)

DEF Text AS
   #<All work and no play makes Jack a dull boy>;
SHAR_EOF
if test -f 'Vowel'
then
    echo shar: over-writing existing file "'Vowel'"
fi
cat << \SHAR_EOF > 'Vowel'
(*
 * Determine if a letter is a vowel.
 *
 * E.g.
 *      A : Vowel -> t
 *      u : Vowel -> t
 *      R : Vowel -> f
 *
 * This function is used by function PigLatin.
 *)

DEF Vowel AS
   [#<a e i o u A E I O U>, id] | member;
SHAR_EOF
if test -f 'cotan'
then
    echo shar: over-writing existing file "'cotan'"
fi
cat << \SHAR_EOF > 'cotan'
(*
 * Trigonmetric cotangent function
 *)

DEF cotan AS [cos,sin] | %;

SHAR_EOF
if test -f 'Euler'
then
    echo shar: over-writing existing file "'Euler'"
fi
cat << \SHAR_EOF > 'Euler'
(*
 * Compute Euler's phi-function, i.e. number of number rel. prime to n.
 *
 * E.g. 8:Euler -> 4 since 1,3,5,7 are relatively prime to 8
 *)
DEF Euler AS
   [id,iota] | distl |
   EACH
      WHILE [2,#0]|> DO [2,mod] END |
      IF [1, #1]|= THEN #1 ELSE #0 END
   END | sum;

SHAR_EOF
if test -f '%DOC'
then
    echo shar: over-writing existing file "'%DOC'"
fi
cat << \SHAR_EOF > '%DOC'
This directory contains demonstration functions.  To use one, enter the
IFP command

     show input : function ;

where input is an appropriate object and function is one of the functions below:

     Abs - absolute value of a number
     cotan - find trigonometric cotangent of angle expressed in radians
     Debug - version of Fib with debugging messages
     Double - double a number
     Euler - Euler totient (phi) function
     Fib - find first n fibonacci numbers
     Inner - find inner product of two vectors
     Inter - set intersection
     Member - set membership
     PigLatin - converts sequence of words to Pig Latin
     PasTri - find first n rows of Pascal's triangle
     QuickSort - sort a sequence of numbers or sequence of strings
     Square - square a number
     Vowel - determine if a string is a vowel

All IFP primitives are imported into this directory also, so you can
experiment with them.  Look in %IMPORT for their names.  The functions
are detailed in the file \IFP.TXT

SHAR_EOF
cd ..
if test ! -d 'math'
then
    mkdir 'math'
fi
cd 'math'
if test ! -d 'arith'
then
    mkdir 'arith'
fi
cd 'arith'
if test -f 'prod'
then
    echo shar: over-writing existing file "'prod'"
fi
cat << \SHAR_EOF > 'prod'
(*
 * prod
 *
 * Compute product of sequence.
 *
 * E.g. <10 2 3 4> : prod -> 240
 *)

DEF prod AS
   IF ../logic/null THEN #1
   ELSE
      INSERT * END
   END;
SHAR_EOF
cd ..
if test ! -d 'linear'
then
    mkdir 'linear'
fi
cd 'linear'
if test -f '%IMPORT'
then
    echo shar: over-writing existing file "'%IMPORT'"
fi
cat << \SHAR_EOF > '%IMPORT'
FROM /sys IMPORT
   apndl,apndr,cat,distr,distl,id,iota,length,tl,trans;

FROM /math/arith IMPORT
   +,-,*,%,exp,ln,sum;

FROM /math/logic IMPORT =,null;
SHAR_EOF
if test -f 'A'
then
    echo shar: over-writing existing file "'A'"
fi
cat << \SHAR_EOF > 'A'
(* Test case generator for L and U - check by trying A | [L,U] | MatMul *)

DEF A AS
   #<
       < 2.3  4.7 -2.7  5.7  7.4 2.1 12.7  1.1 32.1  4.5  1.1  8.3>
       < 1.7 -1.7  5.2  3.2  1.2 3.5  2.4  2.9  1.9  1.7 -4.5 -9.9>
       < 6.1  3.4  1.2 10.6  2.9 1.7  1.1 -0.3  1.2  3.2  1.6  1.3>
       <23.3 -9.7  2.4  5.2  7.6 1.1 86.2  1.7  3.2  9.7  1.2 87.1>
       < 1.2  3.4  4.5  6.7  9.8 0.1  2.1  5.7 -9.1 -5.2  0.2  1.7>
       <12.3  1.2  8.7 12.3 -4.7 -.1  3.2  2.1  4.3  1.8  1.9  2.3>
       < 5.7  4.7 -2.8  5.7  7.4 2.1 12.7  1.1 32.1  4.5  1.1  8.3>
       < 1.7 -6.7  5.6  7.4  1.2 3.5  2.7  2.8  1.9  1.7 -4.5 -9.9>
       < 3.1 -3.4 -9.2 10.6  8.9 1.7 -1.1 -0.3  3.2  3.2  1.6  1.3>
       <13.3 -9.7  5.2  7.6 1.1 86.2  1.3  3.2  9.7  1.2 87.1 -9.2>
       < 1.2  3.4 -4.5 -6.7  9.8 0.1 -2.1  5.8 -9.1 -5.2  0.2  1.7>
       <12.3  1.2 -8.7 12.3 -4.7 -.1 -3.2  1.8  1.9  2.3  3.1  4.3>
   >;

SHAR_EOF
if test -f 'Aik'
then
    echo shar: over-writing existing file "'Aik'"
fi
cat << \SHAR_EOF > 'Aik'
(* Tail of matrix after gaussian elimination on (1|1) *)

DEF Aik AS
   [
      MatTail,
      [Li1|tl,U1k|tl] | Outer
   ] | MatSub;

SHAR_EOF
if test -f 'ApndlCol'
then
    echo shar: over-writing existing file "'ApndlCol'"
fi
cat << \SHAR_EOF > 'ApndlCol'
(* Append column (1) to left side of matrix (2) *)

DEF ApndlCol AS [1,2|trans] | apndl | trans;

SHAR_EOF
if test -f 'ApndrCol'
then
    echo shar: over-writing existing file "'ApndrCol'"
fi
cat << \SHAR_EOF > 'ApndrCol'
(* Append column (2) to right side of matrix (1) *)
DEF ApndrCol [1|trans,2] | apndr | trans;

SHAR_EOF
if test -f 'MatTail'
then
    echo shar: over-writing existing file "'MatTail'"
fi
cat << \SHAR_EOF > 'MatTail'
(* Deletes first row and column of matrix *)
DEF MatTail AS tl | EACH tl END;

SHAR_EOF
if test -f 'Outer'
then
    echo shar: over-writing existing file "'Outer'"
fi
cat << \SHAR_EOF > 'Outer'
(* Outer product of two vectors *)
DEF Outer AS Cart | EACH EACH * END END;

SHAR_EOF
if test -f '%DOC'
then
    echo shar: over-writing existing file "'%DOC'"
fi
cat << \SHAR_EOF > '%DOC'
This directory contains functions for linear matrix manipulation.
In particular, it contains L and U, which take the lower and upper
parts of the LU decomposition of a matrix.
SHAR_EOF
if test -f 'Singleton'
then
    echo shar: over-writing existing file "'Singleton'"
fi
cat << \SHAR_EOF > 'Singleton'
(* Check if matrix is a singleton *)

DEF Singleton AS [length,#1]|=;

SHAR_EOF
if test -f 'U'
then
    echo shar: over-writing existing file "'U'"
fi
cat << \SHAR_EOF > 'U'
(* U part of LU decomposition of matrix *)

DEF U AS
   IF Singleton THEN id
   ELSE
      [
         U1k,
     Aik | [EACH #0 END,U] | ApndlCol
      ] | apndl
   END;

SHAR_EOF
if test -f 'U1k'
then
    echo shar: over-writing existing file "'U1k'"
fi
cat << \SHAR_EOF > 'U1k'
(* First row of U part *)
DEF U1k AS 1;

SHAR_EOF
if test -f 'Cart'
then
    echo shar: over-writing existing file "'Cart'"
fi
cat << \SHAR_EOF > 'Cart'
(* Cartesian product of two vectors *)
DEF Cart AS distr | EACH distl END;

SHAR_EOF
if test -f 'Inner'
then
    echo shar: over-writing existing file "'Inner'"
fi
cat << \SHAR_EOF > 'Inner'
(* Inner product *)

DEF Inner AS
   trans | EACH * END |
   IF null THEN #0
   ELSE INSERT + END
   END;
SHAR_EOF
if test -f 'L'
then
    echo shar: over-writing existing file "'L'"
fi
cat << \SHAR_EOF > 'L'
(* L part of LU decomposition of matrix *)
DEF L AS
   IF Singleton THEN #<<1.0>>
   ELSE
      [
         Li1,
     Aik | [EACH #0 END,L] | apndl
      ] | ApndlCol
   END;

SHAR_EOF
if test -f 'LU'
then
    echo shar: over-writing existing file "'LU'"
fi
cat << \SHAR_EOF > 'LU'
(*
 * LU
 *
 * [L,U] decomposition of matrix written as single function.
 * This function is functionally identical to [L,U]
 *)

DEF LU AS
   IF Singleton THEN [#<<1.0>>,id]        (* definition of L *)
   ELSE
      [
         Li1,
         Aik | [EACH #0 END,LU],
     U1k
      ] |
      [
     [
        1,
        2 | [1,2|1] | apndl
     ] | ApndlCol,
     [
        3,
        2 | [1,2|2] | ApndlCol
     ] | apndl
      ]
   END;
SHAR_EOF
if test -f 'Li1'
then
    echo shar: over-writing existing file "'Li1'"
fi
cat << \SHAR_EOF > 'Li1'
(* First column of L part *)
DEF Li1 AS [EACH 1 END,1|1] | distr | EACH % END;

SHAR_EOF
if test -f 'MatAdd'
then
    echo shar: over-writing existing file "'MatAdd'"
fi
cat << \SHAR_EOF > 'MatAdd'
(* Matrix addition *)
DEF MatAdd AS MatCat | EACH EACH + END END;

SHAR_EOF
if test -f 'MatCat'
then
    echo shar: over-writing existing file "'MatCat'"
fi
cat << \SHAR_EOF > 'MatCat'
(* Converts pair of matrices to matrix of pairs *)

DEF MatCat AS trans | EACH trans END;

SHAR_EOF
if test -f 'MatMul'
then
    echo shar: over-writing existing file "'MatMul'"
fi
cat << \SHAR_EOF > 'MatMul'
DEF MatMul AS
   [1,2|trans] |
   distr |
   EACH distl |
      EACH Inner END
   END;
SHAR_EOF
if test -f 'MatSub'
then
    echo shar: over-writing existing file "'MatSub'"
fi
cat << \SHAR_EOF > 'MatSub'
(* Matrix subtraction *)
DEF MatSub AS MatCat | EACH EACH - END END;

SHAR_EOF
if test -f 'VecAdd'
then
    echo shar: over-writing existing file "'VecAdd'"
fi
cat << \SHAR_EOF > 'VecAdd'
(* Vector addition *)
DEF VecAdd AS trans | EACH + END;

SHAR_EOF
if test -f 'VecSub'
then
    echo shar: over-writing existing file "'VecSub'"
fi
cat << \SHAR_EOF > 'VecSub'
(* Vector subtraction *)
DEF VecSub AS trans | EACH - END;

SHAR_EOF
cd ..
cd ..
cd ..
#    End of shell archive
exit 0

--

Rich $alz            "Anger is an energy"
Cronus Project, BBN Labs    [e-mail]
Moderator, comp.sources.unix    [e-mail]